//关键字 class 
class Person {
    name: string = '';
    age: number = 0;
}
let man = new Person()
man.name = "aa"
man.age = 30
console.log(man);

//类中的构造方法
// 1）:定义一个简单的构造方法
class Dog {
    constructor() {
        console.log('构造一个方法不传参数');

    }
}
const dog = new Dog();

//当我们调 new Dog();的时候我们就等于调用Dog中的构造方法
//在实例犯法中，this就表示当前的实例
//在构造方法中当前对象及时当前新建的那个对象
//可以通过this向新建的对象中添加属性


// 2):定义一个有参构造方法

class Dog1 {
    constructor(name: string) {
        console.log(name);
    }
}
const dog1 = new Dog1("大黄");
//创建的时候必须传递一个string类型的参数
//接口
interface myInter {
    age: number;
    name: string;
    sayHello(): void;

}

class myclass implements myInter {
    age = 1;
    name = '11'
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
    sayHello(): any {
        console.log('xxx');

    }

}
const p = new myclass('aa', 11);
console.log(p.sayHello);
//TS中的属性封装
class Person2 {
    name: string;
    private age: number;
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age
    }
    get names(): string {
        return this.name;
    }

    set names(name: string) {
        this.name = name;
    }
    getAge() {
        return this.age
    }
}
class Dock extends Person2 {
    getAge1(): number {
        return super.getAge()
    }
}
let obj = new Person2("xx", 11)

//泛型
// 在定义函数或类时，如果遇到类型不明确就可以使用泛型
// 泛型就是一个不确定的类型
// 定义一个函数 把传入的参数并返回出去
function cache(prop: string): string {
    return prop;

}
function cache1<T, P>(prop: T, flag: P): T {
    return prop;

}
let a = cache1('1', 1)
// 接口中使用泛型
interface myPerinter<T> {
    name: T
}
class Cat<T, P> implements myPerinter<T> {
    name: T;
    age: P;
    constructor(name: T, age: P) {
        this.name = name;
        this.age = age
    }
}
let obj1 = new Cat<string, number>("xx", 111)
console.log(obj1);
